package mobisnap.mobile_trx;
   
   import java.io.*;
   import java.sql.*;
   import java.util.*;
   import mobisnap.*;
   import nmp.dbms.*;
   import nmp.dbms.JDBC.*;
   import mobisnap.common.reservation.*;
  
  /***
   * Interprets MobisnapSQL
   */
  public class MobisnapInterpreter
  {
  	protected Jdbc_Sql	database;
  	protected TransactionHandle	transaction;
  	protected MobisnapSQL	interpreter;
  	/***
  	 * Used to store the reservation used to process a mobile transaction during
  	 * the course of its execution
  	 */
  	protected Vector refRsrvs;
  	protected Vector usedRsrvs;
  
  	public MobisnapInterpreter( String driverName, String url, String name, String pwd ) throws SQLException {
  		database = new Jdbc_Sql( driverName, url, name, pwd);
  		transaction = database.getTransactionHandle();
  		refRsrvs = new Vector();
  		usedRsrvs = new Vector();
  	}
  	
  	public MobisnapInterpreter( Jdbc_Sql database) throws SQLException {
  		this.database = database;
  		transaction = database.getTransactionHandle();
  		refRsrvs = new Vector();
  		usedRsrvs = new Vector();
  	}
  	
  	/***
  	 * Releases interpreter
  	 */
  	public void release() throws SQLException {
  		if( transaction != null) {
  			transaction.release();
  			transaction = null;
  		}
  		if( database != null) {
  			database.closeAll();
  			database = null;
  		}
  	}
  
  	/***
  	 * Initializes internal structures related with transaction processing
  	 */
  	protected void initTransaction( Reader reader) throws Exception {
  		if( transaction == null)
  			throw new SQLException( "Interpreter not ready");
  		if( interpreter == null) {
  			MobisnapSQL.transaction = transaction;
  			transaction.commit();
  			MobisnapSQL.names = new MSQLNames();
  			interpreter = new MobisnapSQL( reader);
  		} else {
  			transaction.commit();
  			MobisnapSQL.names.reset();
  			MobisnapSQL.ReInit( reader);
  		}
  	}
  	
  	/***
  	 * Initializes internal structures related with query processing
  	 */
  	protected void initQuery( Reader reader) throws Exception {
  		if( database == null)
  			throw new SQLException( "Interpreter not ready");
  		if( interpreter == null) {
  			MobisnapSQL.transaction = transaction;
  			transaction.commit();
  			MobisnapSQL.names = new MSQLNames();
  			interpreter = new MobisnapSQL( reader);
  		} else {
  			transaction.commit();
  			MobisnapSQL.names.reset();
  			MobisnapSQL.ReInit( reader);
  		}
  	}
  
  	/***
  	 * interpreter should be properly initialized - defined only to 
  	 * make the definition visible to outside extensions
  	 */
  	protected ASTDatabaseDefinition databaseDefinition() throws Exception {
  		return MobisnapSQL.DatabaseDefinition();
  	}
  	
  	/***
  	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTCreateSnapshot createSnapshot() throws Exception  {
 		return MobisnapSQL.CreateSnapshot();
 	}
 	
 	/***
 	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTUpdateSnapshot updateSnapshot() throws Exception  {
 		return MobisnapSQL.UpdateSnapshot();
 	}
 	
 	/***
 	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTGetReservation getReservation() throws Exception  {
 		return MobisnapSQL.GetReservation();
 	}
 	
 	/***
 	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTCreateTable createTable( java.util.HashMap map) throws Exception  {
 		return MobisnapSQL.CreateTable( map);
 	}
 	
 	/***
 	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTDropTable dropTable( java.util.HashMap map) throws Exception  {
 		return MobisnapSQL.DropTable(map);
 	}
 	
 	/***
 	 * interpreter should be properly initialized - defined only to 
 	 * make the definition visible to outside extensions
 	 */
 	protected ASTSQLStatement sqlStatement() throws Exception  {
 		return MobisnapSQL.SQLStatement();
 	}
 	
 	/***
 	 * Process a query statement
 	 */
 	public synchronized SQLVectorResult processQuery( int msql_type, Reader reader) throws Exception {
 		initQuery( reader);
 		ASTQueryStatement node = MobisnapSQL.QueryStatement();
 		return node.getResult( msql_type);
 	}
 	
 	/***
 	 * Initializes reservations
 	 */
 	private void initReservations() {
 		refRsrvs.removeAllElements();
 		usedRsrvs.removeAllElements();
 	}
 	
 	/***
 	 * Should be called when some reservation has been associated with any variable
 	 */
 	public void refReservation( ReservationUseBase rsrv) {
 		refRsrvs.addElement( rsrv);
 	}
 	
 	/***
 	 * Should be called when some reservation has effectively been used in the execution
 	 * of the mobile transactions, i.e., when some test has been made that must be
 	 * backed up by the transaction
 	 */
 	public void useReservation( ReservationUseBase rsrv) {
 		usedRsrvs.addElement( rsrv);
 	}
 	
 	/***
 	 * The associated transaction has been commit - used reservations must be updated
 	 */
 	protected void commitReservations() {
 		// do nothing
 	}
 	
 	/***
 	 * The associated reservations has been rollbacked - used reservations must be updated
 	 * If called after "commitReservations" it has no effect
 	 */
 	protected void rollbackReservations() {
 		// do nothing
 	}
 	
 	/***
 	 * Returns the used reservation that backs up the given conditions
 	 * 
 	 * @param table Table name of possible reservation
 	 * @param column Column name of possible reservation
 	 * @param where Table row specification
 	 * @return Returns null if no used reservation backs up the given conbditions
 	 */
 	public ReservationUseBase getUsedReservation( String table, String column, SimpleNode where) {
 		where = where.simplify( MobisnapConstants.MSQL_SERVER, false);
 		Enumeration enum = usedRsrvs.elements();
 		while( enum.hasMoreElements()) {
 			ReservationUseBase rsrv = (ReservationUseBase)enum.nextElement();
 			if( rsrv.getRsrv().checkReservation( table, column, where))
 				return rsrv;
 		}
 		return null;
 	}
 	
 	/***
 	 * Returns the used reservation that backs up the given conditions
 	 * 
 	 * @param table Table name of possible reservation
 	 * @param column Column name of possible reservation
 	 * @param conditions Table row specification
 	 * @return Returns null if no used reservation backs up the given conbditions
 	 */
 	public ReservationUseBase getUsedReservation( String table, String column, Vector conditions) {
 		Enumeration enum = usedRsrvs.elements();
 		while( enum.hasMoreElements()) {
 			ReservationUseBase rsrv = (ReservationUseBase)enum.nextElement();
 			if( rsrv.getRsrv().checkReservation( table, column, conditions))
 				return rsrv;
 		}
 		return null;
 	}
 	
 
 	/***
 	 * Process a mobile transaction
 	 * 
 	 * @param msql_type Processing type (server, client tentative, client reservation)
 	 * @param reader Reader to read mobile transaction
 	 */
 	public int processMSQLTrx( Reader reader) throws Exception {
 		return processMSQLTrx( MobisnapConstants.MSQL_SERVER, reader);
 	}
 	public synchronized int processMSQLTrx( int msql_type, Reader reader) throws Exception {
 		initTransaction( reader);
 		SimpleNode mainNode = MobisnapSQL.CompilationUnit() ;
 		if( msql_type == MobisnapConstants.MSQL_RESERVATION_CLIENT) {
 			try {
 				initReservations();
 				mainNode.process( msql_type);
 				throw new mobisnap.MobisnapException( "Internal error - compilation unit ended without a result");
 			} catch( CommitException e) {
 				commitReservations();
 				return MobisnapConstants.MSQLCR_RESERVATION_COMMIT;
 			} catch( UnknownException e) {
 				transaction.rollback();
 				return MobisnapConstants.MSQLCR_UNKNOWN;
 			} catch( RollbackException e) {
 				  // do nothing
 			} catch( NoReservationException e) {
 				  // do nothing
 			} finally {
 				rollbackReservations();
 			}
 			msql_type = MobisnapConstants.MSQL_TENTATIVE_CLIENT;
 		}
 		if( msql_type == MobisnapConstants.MSQL_SERVER) {
 			try {
 				mainNode.process( msql_type);
 				throw new mobisnap.MobisnapException( "Internal error - compilation unit ended without a result");
 			} catch( CommitException e) {
 				return MobisnapConstants.MSQLSR_COMMIT;
 			} catch( RollbackException e) {
 				return MobisnapConstants.MSQLSR_ABORT;
 			} catch( UnknownException e) {
 				transaction.rollback();
 				return MobisnapConstants.MSQLSR_ABORT;
 			}
 		} else {
 			try {
 				mainNode.process( msql_type);
 				throw new mobisnap.MobisnapException( "Internal error - compilation unit ended without a result");
 			} catch( CommitException e) {
 				return MobisnapConstants.MSQLCR_TENTATIVE_COMMIT;
 			} catch( RollbackException e) {
 				return MobisnapConstants.MSQLCR_TENTATIVE_ABORT;
 			} catch( UnknownException e) {
 				transaction.rollback();
 				return MobisnapConstants.MSQLCR_UNKNOWN;
 			}
 		}
 	}
 
 	/***
 	 * Process a database definition : syntax : begin (sql_ddl_statements)* end ;
 	 */
 	public synchronized void processDatabaseDef( Reader reader, Hashtable table) throws Exception {
 		initQuery( reader);
 		ASTDatabaseDefinition node = databaseDefinition();
 		Iterator it = node.definitions().iterator();
 		while( it.hasNext()) {
 			SimpleNode aux = (SimpleNode)it.next();
 			if( aux instanceof ASTCreateTable) {
 				ASTCreateTable ct = (ASTCreateTable)aux;
 				StringBuffer buffer = new StringBuffer();
 				ct.sourceCode( MobisnapConstants.MSQL_SERVER, buffer);
 				table.put( ct.tableName( MobisnapConstants.MSQL_SERVER), buffer.toString().trim());
 			} else 
 				System.err.println( "instruction not processed");
 		}
 	}
 
 	public static void main( String[] args) {
 		try {
 			MobisnapInterpreter interpreter = null;
 			try { 
 				System.out.println( "Usage:\nMobisnapInterpreter filename [url user pwd [driver]]");
 				if( args.length == 5)
 					interpreter = new MobisnapInterpreter( args[4], args[1], args[2], args[3]);
 				else if( args.length == 4)
 					interpreter = new MobisnapInterpreter( "sun.jdbc.odbc.JdbcOdbcDriver", args[1], args[2], args[3]);
 				else
 					interpreter = new MobisnapInterpreter( "sun.jdbc.odbc.JdbcOdbcDriver", "jdbc:odbc:wine", "nmp", "");
 
 				interpreter.processMSQLTrx( MobisnapConstants.MSQL_SERVER, new FileReader( args[0]));
 
 			} finally {
 				interpreter.release();
 			}
 		} catch( Exception e) {
 			e.printStackTrace();
 		}
 	}
 }